{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression with a Neural Network mindset\n",
    "\n",
    "Welcome to your first (required) programming assignment! You will build a logistic regression classifier to recognize  cats. This assignment will step you through how to do this with a Neural Network mindset, and so will also hone your intuitions about deep learning.\n",
    "\n",
    "**Instructions:**\n",
    "- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.\n",
    "\n",
    "**You will learn to:**\n",
    "- Build the general architecture of a learning algorithm, including:\n",
    "    - Initializing parameters\n",
    "    - Calculating the cost function and its gradient\n",
    "    - Using an optimization algorithm (gradient descent) \n",
    "- Gather all three functions above into a main model function, in the right order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Packages ##\n",
    "\n",
    "First, let's run the cell below to import all the packages that you will need during this assignment. \n",
    "- [numpy](www.numpy.org) is the fundamental package for scientific computing with Python.\n",
    "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n",
    "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python.\n",
    "- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from lr_utils import load_dataset\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2 - Overview of the Problem set ##\n",
    "\n",
    "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n",
    "    - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n",
    "    - a test set of m_test images labeled as cat or non-cat\n",
    "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n",
    "\n",
    "You will build a simple image-recognition algorithm that can correctly classify pictures as cat or non-cat.\n",
    "\n",
    "Let's get more familiar with the dataset. Load the data by running the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the data (cat/non-cat)\n",
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We added \"_orig\" at the end of image datasets (train and test) because we are going to preprocess them. After preprocessing, we will end up with train_set_x and test_set_x (the labels train_set_y and test_set_y don't need any preprocessing).\n",
    "\n",
    "Each line of your train_set_x_orig and test_set_x_orig is an array representing an image. You can visualize an example by running the following code. Feel free also to change the `index` value and re-run to see other images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = [1], it's a 'cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c06d2c8780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 25\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many software bugs in deep learning come from having matrix/vector dimensions that don't fit. If you can keep your matrix/vector dimensions straight you will go a long way toward eliminating many bugs. \n",
    "\n",
    "**Exercise:** Find the values for:\n",
    "    - m_train (number of training examples)\n",
    "    - m_test (number of test examples)\n",
    "    - num_px (= height = width of a training image)\n",
    "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 209\n",
      "Number of testing examples: m_test = 50\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (209, 64, 64, 3)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x shape: (50, 64, 64, 3)\n",
      "test_set_y shape: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "### START CODE HERE ### (≈ 3 lines of code)\n",
    "m_train = train_set_x_orig.shape[0]\n",
    "m_test = test_set_x_orig.shape[0]\n",
    "num_px = train_set_x_orig.shape[1]\n",
    "### END CODE HERE ###\n",
    "\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output for m_train, m_test and num_px**: \n",
    "<table style=\"width:15%\">\n",
    "  <tr>\n",
    "    <td>**m_train**</td>\n",
    "    <td> 209 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**m_test**</td>\n",
    "    <td> 50 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**num_px**</td>\n",
    "    <td> 64 </td> \n",
    "  </tr>\n",
    "  \n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n",
    "\n",
    "**Exercise:** Reshape the training and test data sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n",
    "\n",
    "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n",
    "```python\n",
    "X_flatten = X.reshape(X.shape[0], -1).T      # X.T is the transpose of X\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x_flatten shape: (12288, 209)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x_flatten shape: (12288, 50)\n",
      "test_set_y shape: (1, 50)\n",
      "sanity check after reshaping: [17 31 56 22 33]\n"
     ]
    }
   ],
   "source": [
    "# Reshape the training and test examples\n",
    "\n",
    "### START CODE HERE ### (≈ 2 lines of code)\n",
    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
    "### END CODE HERE ###\n",
    "\n",
    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))\n",
    "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:35%\">\n",
    "  <tr>\n",
    "    <td>**train_set_x_flatten shape**</td>\n",
    "    <td> (12288, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**train_set_y shape**</td>\n",
    "    <td>(1, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**test_set_x_flatten shape**</td>\n",
    "    <td>(12288, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**test_set_y shape**</td>\n",
    "    <td>(1, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "  <td>**sanity check after reshaping**</td>\n",
    "  <td>[17 31 56 22 33]</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To represent color images, the red, green and blue channels (RGB) must be specified for each pixel, and so the pixel value is actually a vector of three numbers ranging from 0 to 255.\n",
    "\n",
    "One common preprocessing step in machine learning is to center and standardize your dataset, meaning that you substract the mean of the whole numpy array from each example, and then divide each example by the standard deviation of the whole numpy array. But for picture datasets, it is simpler and more convenient and works almost as well to just divide every row of the dataset by 255 (the maximum value of a pixel channel).\n",
    "\n",
    "<!-- During the training of your model, you're going to multiply weights and add biases to some initial inputs in order to observe neuron activations. Then you backpropogate with the gradients to train the model. But, it is extremely important for each feature to have a similar range such that our gradients don't explode. You will see that more in detail later in the lectures. !--> \n",
    "\n",
    "Let's standardize our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten/255.\n",
    "test_set_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**What you need to remember:**\n",
    "\n",
    "Common steps for pre-processing a new dataset are:\n",
    "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n",
    "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n",
    "- \"Standardize\" the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - General Architecture of the learning algorithm ##\n",
    "\n",
    "It's time to design a simple algorithm to distinguish cat images from non-cat images.\n",
    "\n",
    "You will build a Logistic Regression, using a Neural Network mindset. The following Figure explains why **Logistic Regression is actually a very simple Neural Network!**\n",
    "\n",
    "<img src=\"images/LogReg_kiank.png\" style=\"width:650px;height:400px;\">\n",
    "\n",
    "**Mathematical expression of the algorithm**:\n",
    "\n",
    "For one example $x^{(i)}$:\n",
    "$$z^{(i)} = w^T x^{(i)} + b \\tag{1}$$\n",
    "$$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\\tag{2}$$ \n",
    "$$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})\\tag{3}$$\n",
    "\n",
    "The cost is then computed by summing over all training examples:\n",
    "$$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})\\tag{6}$$\n",
    "\n",
    "**Key steps**:\n",
    "In this exercise, you will carry out the following steps: \n",
    "    - Initialize the parameters of the model\n",
    "    - Learn the parameters for the model by minimizing the cost  \n",
    "    - Use the learned parameters to make predictions (on the test set)\n",
    "    - Analyse the results and conclude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Building the parts of our algorithm ## \n",
    "\n",
    "The main steps for building a Neural Network are:\n",
    "1. Define the model structure (such as number of input features) \n",
    "2. Initialize the model's parameters\n",
    "3. Loop:\n",
    "    - Calculate current loss (forward propagation)\n",
    "    - Calculate current gradient (backward propagation)\n",
    "    - Update parameters (gradient descent)\n",
    "\n",
    "You often build 1-3 separately and integrate them into one function we call `model()`.\n",
    "\n",
    "### 4.1 - Helper functions\n",
    "\n",
    "**Exercise**: Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid( w^T x + b) = \\frac{1}{1 + e^{-(w^T x + b)}}$ to make predictions. Use np.exp()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: sigmoid\n",
    "\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Compute the sigmoid of z\n",
    "\n",
    "    Arguments:\n",
    "    z -- A scalar or numpy array of any size.\n",
    "\n",
    "    Return:\n",
    "    s -- sigmoid(z)\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    s = 1/(1+np.exp(-z))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid([0, 2]) = [0.5        0.88079708]\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table>\n",
    "  <tr>\n",
    "    <td>**sigmoid([0, 2])**</td>\n",
    "    <td> [ 0.5         0.88079708]</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 - Initializing parameters\n",
    "\n",
    "**Exercise:** Implement parameter initialization in the cell below. You have to initialize w as a vector of zeros. If you don't know what numpy function to use, look up np.zeros() in the Numpy library's documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_with_zeros\n",
    "\n",
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
    "    \n",
    "    Argument:\n",
    "    dim -- size of the w vector we want (or number of parameters in this case)\n",
    "    \n",
    "    Returns:\n",
    "    w -- initialized vector of shape (dim, 1)\n",
    "    b -- initialized scalar (corresponds to the bias)\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    w = np.zeros((dim, 1))\n",
    "    b = 0\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    assert(w.shape == (dim, 1))\n",
    "    assert(isinstance(b, float) or isinstance(b, int))\n",
    "    \n",
    "    return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.]\n",
      " [0.]]\n",
      "b = 0\n"
     ]
    }
   ],
   "source": [
    "dim = 2\n",
    "w, b = initialize_with_zeros(dim)\n",
    "print (\"w = \" + str(w))\n",
    "print (\"b = \" + str(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "\n",
    "<table style=\"width:15%\">\n",
    "    <tr>\n",
    "        <td>  ** w **  </td>\n",
    "        <td> [[ 0.]\n",
    " [ 0.]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** b **  </td>\n",
    "        <td> 0 </td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "For image inputs, w will be of shape (num_px $\\times$ num_px $\\times$ 3, 1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 - Forward and Backward propagation\n",
    "\n",
    "Now that your parameters are initialized, you can do the \"forward\" and \"backward\" propagation steps for learning the parameters.\n",
    "\n",
    "**Exercise:** Implement a function `propagate()` that computes the cost function and its gradient.\n",
    "\n",
    "**Hints**:\n",
    "\n",
    "Forward Propagation:\n",
    "- You get X\n",
    "- You compute $A = \\sigma(w^T X + b) = (a^{(0)}, a^{(1)}, ..., a^{(m-1)}, a^{(m)})$\n",
    "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)})$\n",
    "\n",
    "Here are the two formulas you will be using: \n",
    "\n",
    "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n",
    "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: propagate\n",
    "\n",
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    Implement the cost function and its gradient for the propagation explained above\n",
    "\n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
    "\n",
    "    Return:\n",
    "    cost -- negative log-likelihood cost for logistic regression\n",
    "    dw -- gradient of the loss with respect to w, thus same shape as w\n",
    "    db -- gradient of the loss with respect to b, thus same shape as b\n",
    "    \n",
    "    Tips:\n",
    "    - Write your code step by step for the propagation. np.log(), np.dot()\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    \n",
    "    # FORWARD PROPAGATION (FROM X TO COST)\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    A = sigmoid(np.dot(w.T, X) + b)            # compute activation (1, num)\n",
    "    cost = np.sum(Y * np.log(A) + (1-Y)*np.log(1-A)) * -1/m     # compute cost\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    dw = np.dot(X, (A-Y).T) / m\n",
    "    db = np.sum(A - Y) / m\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return grads, cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[0.99993216]\n",
      " [1.99980262]]\n",
      "db = 0.49993523062470574\n",
      "cost = 6.000064773192205\n"
     ]
    }
   ],
   "source": [
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table style=\"width:50%\">\n",
    "    <tr>\n",
    "        <td>  ** dw **  </td>\n",
    "        <td> [[ 0.99993216]\n",
    " [ 1.99980262]]</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** db **  </td>\n",
    "        <td> 0.499935230625 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** cost **  </td>\n",
    "        <td> 6.000064773192205</td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d) Optimization\n",
    "- You have initialized your parameters.\n",
    "- You are also able to compute a cost function and its gradient.\n",
    "- Now, you want to update the parameters using gradient descent.\n",
    "\n",
    "**Exercise:** Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: optimize\n",
    "\n",
    "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "    \"\"\"\n",
    "    This function optimizes w and b by running a gradient descent algorithm\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of shape (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
    "    num_iterations -- number of iterations of the optimization loop\n",
    "    learning_rate -- learning rate of the gradient descent update rule\n",
    "    print_cost -- True to print the loss every 100 steps\n",
    "    \n",
    "    Returns:\n",
    "    params -- dictionary containing the weights w and bias b\n",
    "    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
    "    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
    "    \n",
    "    Tips:\n",
    "    You basically need to write down two steps and iterate through them:\n",
    "        1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
    "        2) Update the parameters using gradient descent rule for w and b.\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        \n",
    "        \n",
    "        # Cost and gradient calculation (≈ 1-4 lines of code)\n",
    "        ### START CODE HERE ### \n",
    "        grads, cost = propagate(w, b, X, Y)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Retrieve derivatives from grads\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        # update rule (≈ 2 lines of code)\n",
    "        ### START CODE HERE ###\n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Record the costs\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        \n",
    "        # Print the cost every 100 training examples\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "    \n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return params, grads, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.1124579 ]\n",
      " [0.23106775]]\n",
      "b = 1.5593049248448891\n",
      "dw = [[0.90158428]\n",
      " [1.76250842]]\n",
      "db = 0.4304620716786828\n"
     ]
    }
   ],
   "source": [
    "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
    "\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\">\n",
    "    <tr>\n",
    "       <td> **w** </td>\n",
    "       <td>[[ 0.1124579 ]\n",
    " [ 0.23106775]] </td>\n",
    "    </tr>\n",
    "    \n",
    "    <tr>\n",
    "       <td> **b** </td>\n",
    "       <td> 1.55930492484 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **dw** </td>\n",
    "       <td> [[ 0.90158428]\n",
    " [ 1.76250842]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **db** </td>\n",
    "       <td> 0.430462071679 </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The previous function will output the learned w and b. We are able to use w and b to predict the labels for a dataset X. Implement the `predict()` function. There is two steps to computing predictions:\n",
    "\n",
    "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n",
    "\n",
    "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: predict\n",
    "\n",
    "def predict(w, b, X):\n",
    "    '''\n",
    "    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    \n",
    "    Returns:\n",
    "    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
    "    '''\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "    w = w.reshape(X.shape[0], 1)\n",
    "    \n",
    "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    A = sigmoid(np.dot(w.T, X) + b)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    for i in range(A.shape[1]):\n",
    "        \n",
    "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
    "        ### START CODE HERE ### (≈ 4 lines of code)\n",
    "        Y_prediction[0, i] = 1 if A[0, i] > 0.5 else 0\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    assert(Y_prediction.shape == (1, m))\n",
    "    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print (\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:30%\">\n",
    "    <tr>\n",
    "         <td>\n",
    "             **predictions**\n",
    "         </td>\n",
    "          <td>\n",
    "            [[ 1.  1.]]\n",
    "         </td>  \n",
    "   </tr>\n",
    "\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<font color='blue'>\n",
    "**What to remember:**\n",
    "You've implemented several functions that:\n",
    "- Initialize (w,b)\n",
    "- Optimize the loss iteratively to learn parameters (w,b):\n",
    "    - computing the cost and its gradient \n",
    "    - updating the parameters using gradient descent\n",
    "- Use the learned (w,b) to predict the labels for a given set of examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - Merge all functions into a model ##\n",
    "\n",
    "You will now see how the overall model is structured by putting together all the building blocks (functions implemented in the previous parts) together, in the right order.\n",
    "\n",
    "**Exercise:** Implement the model function. Use the following notation:\n",
    "    - Y_prediction for your predictions on the test set\n",
    "    - Y_prediction_train for your predictions on the train set\n",
    "    - w, costs, grads for the outputs of optimize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: model\n",
    "\n",
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "    \"\"\"\n",
    "    Builds the logistic regression model by calling the function you've implemented previously\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
    "    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
    "    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
    "    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
    "    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
    "    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
    "    print_cost -- Set to true to print the cost every 100 iterations\n",
    "    \n",
    "    Returns:\n",
    "    d -- dictionary containing information about the model.\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # initialize parameters with zeros (≈ 1 line of code)\n",
    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
    "\n",
    "    # Gradient descent (≈ 1 line of code)\n",
    "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
    "    \n",
    "    # Retrieve parameters w and b from dictionary \"parameters\"\n",
    "    w = parameters[\"w\"]\n",
    "    b = parameters[\"b\"]\n",
    "    \n",
    "    # Predict test/train set examples (≈ 2 lines of code)\n",
    "    Y_prediction_test = predict(w, b, X_test)\n",
    "    Y_prediction_train = predict(w, b, X_train)\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Print train/test Errors\n",
    "    print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
    "    print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
    "\n",
    "    \n",
    "    d = {\"costs\": costs,\n",
    "         \"Y_prediction_test\": Y_prediction_test, \n",
    "         \"Y_prediction_train\" : Y_prediction_train, \n",
    "         \"w\" : w, \n",
    "         \"b\" : b,\n",
    "         \"learning_rate\" : learning_rate,\n",
    "         \"num_iterations\": num_iterations}\n",
    "    \n",
    "    return d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following cell to train your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.584508\n",
      "Cost after iteration 200: 0.466949\n",
      "Cost after iteration 300: 0.376007\n",
      "Cost after iteration 400: 0.331463\n",
      "Cost after iteration 500: 0.303273\n",
      "Cost after iteration 600: 0.279880\n",
      "Cost after iteration 700: 0.260042\n",
      "Cost after iteration 800: 0.242941\n",
      "Cost after iteration 900: 0.228004\n",
      "Cost after iteration 1000: 0.214820\n",
      "Cost after iteration 1100: 0.203078\n",
      "Cost after iteration 1200: 0.192544\n",
      "Cost after iteration 1300: 0.183033\n",
      "Cost after iteration 1400: 0.174399\n",
      "Cost after iteration 1500: 0.166521\n",
      "Cost after iteration 1600: 0.159305\n",
      "Cost after iteration 1700: 0.152667\n",
      "Cost after iteration 1800: 0.146542\n",
      "Cost after iteration 1900: 0.140872\n",
      "train accuracy: 99.04306220095694 %\n",
      "test accuracy: 70.0 %\n"
     ]
    }
   ],
   "source": [
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\"> \n",
    "    \n",
    "    <tr>\n",
    "        <td> **Train Accuracy**  </td> \n",
    "        <td> 99.04306220095694 % </td>\n",
    "    </tr>\n",
    "\n",
    "    <tr>\n",
    "        <td>**Test Accuracy** </td> \n",
    "        <td> 70.0 % </td>\n",
    "    </tr>\n",
    "</table> \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Comment**: Training accuracy is close to 100%. This is a good sanity check: your model is working and has high enough capacity to fit the training data. Test error is 68%. It is actually not bad for this simple model, given the small dataset we used and that logistic regression is a linear classifier. But no worries, you'll build an even better classifier next week!\n",
    "\n",
    "Also, you see that the model is clearly overfitting the training data. Later in this specialization you will learn how to reduce overfitting, for example by using regularization. Using the code below (and changing the `index` variable) you can look at predictions on pictures of the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-50a2ff1ec91d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mindex\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_set_x\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_px\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"y = \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_set_y\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m\", you predicted that it is a \\\"\"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mclasses\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"Y_prediction_test\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"utf-8\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m  \u001b[1;34m\"\\\" picture.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c06d513240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture that was wrongly classified.\n",
    "index = 1\n",
    "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[d[\"Y_prediction_test\"][0,index]].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also plot the cost function and the gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c06d50e748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot learning curve (with costs)\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Interpretation**:\n",
    "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 - Further analysis (optional/ungraded exercise) ##\n",
    "\n",
    "Congratulations on building your first image classification model. Let's analyze it further, and examine possible choices for the learning rate $\\alpha$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Choice of learning rate ####\n",
    "\n",
    "**Reminder**:\n",
    "In order for Gradient Descent to work you must choose the learning rate wisely. The learning rate $\\alpha$  determines how rapidly we update the parameters. If the learning rate is too large we may \"overshoot\" the optimal value. Similarly, if it is too small we will need too many iterations to converge to the best values. That's why it is crucial to use a well-tuned learning rate.\n",
    "\n",
    "Let's compare the learning curve of our model with several choices of learning rates. Run the cell below. This should take about 1 minute. Feel free also to try different values than the three we have initialized the `learning_rates` variable to contain, and see what happens. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learning rate is: 0.01\n",
      "train accuracy: 99.52153110047847 %\n",
      "test accuracy: 68.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.001\n",
      "train accuracy: 88.99521531100478 %\n",
      "test accuracy: 64.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.0001\n",
      "train accuracy: 68.42105263157895 %\n",
      "test accuracy: 36.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c06d3cdfd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "for i in learning_rates:\n",
    "    print (\"learning rate is: \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center', shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Interpretation**: \n",
    "- Different learning rates give different costs and thus different predictions results.\n",
    "- If the learning rate is too large (0.01), the cost may oscillate up and down. It may even diverge (though in this example, using 0.01 still eventually ends up at a good value for the cost). \n",
    "- A lower cost doesn't mean a better model. You have to check if there is possibly overfitting. It happens when the training accuracy is a lot higher than the test accuracy.\n",
    "- In deep learning, we usually recommend that you: \n",
    "    - Choose the learning rate that better minimizes the cost function.\n",
    "    - If your model overfits, use other techniques to reduce overfitting. (We'll talk about this in later videos.) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 7 - Test with your own image (optional/ungraded exercise) ##\n",
    "\n",
    "Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:\n",
    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
    "    3. Change your image's name in the following code\n",
    "    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program_files\\anaconda\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  import sys\n",
      "d:\\program_files\\anaconda\\lib\\site-packages\\ipykernel_launcher.py:8: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1.0, your algorithm predicts a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c06d2b78d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
    "my_image = \"my_image2.jpg\"   # change this to the name of your image file \n",
    "## END CODE HERE ##\n",
    "\n",
    "# We preprocess the image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((1, num_px*num_px*3)).T\n",
    "my_predicted_image = predict(d[\"w\"], d[\"b\"], my_image)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**What to remember from this assignment:**\n",
    "1. Preprocessing the dataset is important.\n",
    "2. You implemented each function separately: initialize(), propagate(), optimize(). Then you built a model().\n",
    "3. Tuning the learning rate (which is an example of a \"hyperparameter\") can make a big difference to the algorithm. You will see more examples of this later in this course!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if you'd like, we invite you to try different things on this Notebook. Make sure you submit before trying anything. Once you submit, things you can play with include:\n",
    "    - Play with the learning rate and the number of iterations\n",
    "    - Try different initialization methods and compare the results\n",
    "    - Test other preprocessings (center the data, or divide each row by its standard deviation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bibliography:\n",
    "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n",
    "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "neural-networks-deep-learning",
   "graded_item_id": "XaIWT",
   "launcher_item_id": "zAgPl"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
